Laboratorio No. 2 - Regresión Lineal¶
Maria José Castro Lemus
Paula Camila González Ortega
Adjunto a este NoteBook encontrarán el archivo Autos-csv que contiene datos sobre automóviles de segunda mano. El objetivo principal de este ejercicio es desarrollar un modelo que permita, en base a las características (features) que tiene el archivo, predecir el costo de un vehículo usado.
A diferencia de la mayoría de ejercicios, este archivo no ha sido depurado, es decir los datos son crudos (raw). Esto quiere decir que antes de trabajar sobre un modelo predictivo, deben realizar el proceso total, desde limpieza de datos, exploración inicial, etc.
A continuación encontrarán que hay encabezados que bien podrían ayudarlos a desarrollar el código requerido. Estos están a manera de sugerencia únicamente y Ustedes decidirán si los usan, modifican, eliminan, agregan a los mismos
Importar las librerías relevantes¶
In [7]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from quickda.explore_data import *
from quickda.clean_data import *
from quickda.explore_numeric import *
from quickda.explore_categoric import *
from quickda.explore_numeric_categoric import *
from quickda.explore_time_series import *
%matplotlib inline
Cargar los datos crudos¶
In [2]:
raw_df = pd.read_csv('Autos.csv')
In [3]:
raw_df.head()
Out[3]:
In [4]:
raw_df.info()
Preprocesamiento¶
Explorar las estadísticas descriptivas de las variables¶
In [5]:
raw_df.describe()
Out[5]:
In [8]:
explore(raw_df, method="summarize")
Out[8]:
In [9]:
sns.pairplot(raw_df)
Out[9]:
Determinación de las variables de interés¶
In [10]:
raw_df.columns
Out[10]:
In [11]:
X = raw_df[['Brand','Body', 'Mileage', 'EngineV', 'Engine Type','Year']]
y = raw_df['Price']
print(X,y)
In [12]:
eda_numcat(raw_df, "Price",
method = "pps")
Manejo de valores faltantes¶
In [13]:
sns.heatmap(raw_df.isnull(),yticklabels=False,cbar=False,cmap='viridis')
Out[13]:
In [14]:
raw_df['EngineV'].isna().sum()
Out[14]:
In [15]:
raw_df['Price'].isna().sum()
Out[15]:
In [16]:
# se les pone el precio promedio
def imputar_precios(cols):
precio = cols[0]
if pd.isnull(precio):
return 19418.74
else:
return precio
In [17]:
# se les pone el enginev promedio
def imputar_enginev(cols):
enginev = cols[0]
if pd.isnull(enginev):
return 2.79
else:
return enginev
In [18]:
raw_df['Price'] = raw_df[['Price']].apply(imputar_precios,axis=1) #axis 1 es columnas
In [19]:
raw_df['EngineV'] = raw_df[['EngineV']].apply(imputar_enginev,axis=1) #axis 1 es columnas
In [20]:
sns.heatmap(raw_df.isnull(),yticklabels=False,cbar=False,cmap='viridis')
Out[20]:
Exploración de las Funciones de Distribución de Probabilidades (PDFs por sus siglas en inglés)¶
In [21]:
raw_df['Price'].hist(color='green',bins=40,figsize=(8,4))
Out[21]:
In [22]:
raw_df['Mileage'].hist(color='green',bins=40,figsize=(8,4))
#Descartada por su distribucion
Out[22]:
In [23]:
raw_df['Year'].hist(color='green',bins=40,figsize=(8,4))
#Descartada por su distribucion
Out[23]:
In [24]:
raw_df['EngineV'].hist(color='green',bins=40,figsize=(8,4))
Out[24]:
Manejo de valores atípicos (outliers)¶
In [25]:
plt.figure(figsize=(15, 7))
sns.boxplot(x='Brand',y='Price',data=raw_df,palette='winter')
Out[25]:
In [26]:
plt.figure(figsize=(15, 7))
sns.boxplot(x='Body',y='Price',data=raw_df,palette='winter')
Out[26]:
In [27]:
plt.figure(figsize=(15, 7))
sns.boxplot(x='Engine Type',y='Price',data=raw_df,palette='winter')
Out[27]:
In [30]:
raw_df = clean(raw_df, method="outliers",
columns=[])
Revisando los supuestos para OLS¶
In [31]:
import statsmodels.api as sm
y = raw_df['Price']
x1 = raw_df[['Mileage', 'EngineV', 'Year']]
x = sm.add_constant(x1)
results = sm.OLS(y,x).fit()
results.summary()
Out[31]:
In [32]:
#matriz de correlación
sns.heatmap(raw_df.corr(), annot = True)
Out[32]:
Multicolinealidad¶
In [33]:
from statsmodels.stats.outliers_influence import variance_inflation_factor
def calc_vif(X):
# Calculating VIF
vif = pd.DataFrame()
vif["variables"] = X.columns
vif["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]
return(vif)
In [34]:
X = raw_df[['Mileage', 'EngineV', 'Year']]
calc_vif(X)
Out[34]:
Crear variables comodín (Dummy)¶
In [35]:
marca = pd.get_dummies(raw_df['Brand'], drop_first=True)
marca
Out[35]:
In [36]:
tipo = pd.get_dummies(raw_df['Body'], drop_first=True)
tipo
Out[36]:
In [37]:
combustible = pd.get_dummies(raw_df['Engine Type'], drop_first=True)
combustible
Out[37]:
Re-ordenar un poco¶
In [38]:
train = pd.concat([raw_df,marca,tipo,combustible],axis=1) #le agregamos las columnas dummies que creamos antes
train.head()
Out[38]:
In [39]:
train.columns
Out[39]:
Modelo de regresión lineal¶
Declarar las entradas y las metas¶
In [40]:
#X = raw_df[['Brand','Body', 'Mileage', 'EngineV', 'Engine Type','Year']]
X = train[['Mileage', 'EngineV','Year', 'BMW', 'Mercedes-Benz', 'Mitsubishi',
'Renault', 'Toyota', 'Volkswagen', 'hatch', 'other', 'sedan', 'vagon',
'van', 'Gas', 'Other', 'Petrol']]
#X = train[['Mileage', 'EngineV','Year']]
y = train['Price']
print(X,y)
Escalar (poner a escala) los datos¶
In [41]:
from sklearn.preprocessing import StandardScaler
escalador = StandardScaler()
escalador.fit(X)
cols_std = escalador.transform(X)
print(cols_std)
In [42]:
type(cols_std)
Out[42]:
In [43]:
df_std = pd.DataFrame(cols_std, columns=X.columns)
df_std.head()
Out[43]:
Divisón del df completo en datos de entrenamiento y de prueba (Train Test Split)¶
In [44]:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,
train['Price'], test_size=0.30,
random_state=101)
# X son todos menos price y Y es solo la columna price
Crear la regresión¶
In [45]:
from sklearn.linear_model import LinearRegression
lm = LinearRegression()
lm.fit(X_train,y_train)
Out[45]:
In [46]:
predicciones = lm.predict(X_test)
Encontrar R^2 del modelo¶
In [47]:
from sklearn.metrics import r2_score
r2 = r2_score(y_test,predicciones)
print(r2)
Nótese que este no es el R^2 ajustado. En otras palabras hay que encontrar el R^2 ajustado para tener una medida más adecuada
Fórmula para R^2 Ajustado¶
n = número de observaciones
p = número de predictores
In [48]:
p = len(predicciones)
n = X.shape[1]
r2_ajustado = 1 - (1-r2)*((n-1)/(n-p-1))
print(r2_ajustado)
Encontrar los pesos (coeficientes) y el sesgo (intercepto)¶
In [49]:
coeficientes = pd.DataFrame(lm.coef_, X.columns, columns=['Coeficiente'])
coeficientes
Out[49]:
In [50]:
# imprimir la intercepción (constante)
print(lm.intercept_)
Prueba del modelo¶
In [56]:
plt.xlim(0, 45000)
plt.ylim(0, 45000)
plt.scatter(y_test,predicciones)
Out[56]:
In [57]:
sns.displot((y_test - predicciones),bins=50);
In [58]:
from sklearn import metrics
print('MAE:', metrics.mean_absolute_error(y_test, predicciones))
print('MSE:', metrics.mean_squared_error(y_test, predicciones))
print('RMSE:', np.sqrt(metrics.mean_squared_error(y_test, predicciones)))
Conclusiones¶
La marca, el tipo, el millaje, los cilindros, el tipo de combustible y año son factores que afectan linealmente el precio de un carro
El año y millaje son variables con alta multicolinealidad por lo que el valor de una tiene impacto en la otra
Al evaluar las métricas de errores para la regresión lineal se determinó que estas se encuentran dentro del estándar y por lo tanto se realizó correctamente el training de la data y posteriormente la predicción